/*
 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "base/log/dump_log.h"

#include <fstream>
#include <new>
#include <ostream>
#include <string>

#include "base/log/log_wrapper.h"
#include "base/utils/utils.h"
#include "core/common/ace_application_info.h"

namespace OHOS::Ace {

DumpLog::DumpLog() = default;
DumpLog::~DumpLog() = default;

void DumpLog::Print(int32_t depth, const std::string& className, int32_t childSize)
{
    if (!ostream_->good()) {
        return;
    }
    std::string space = "  ";
    for (int32_t i = 0; i < depth; ++i) {
        ostream_->write(space.c_str(), space.length());
    }
    ostream_->write(space.c_str(), space.length());
    std::string data = "|-> ";
    data.append(className);
    data.append(" childSize:" + std::to_string(childSize));
    data.append("\n");
    ostream_->write(data.c_str(), data.length());
    for (auto& desc : description_) {
        for (int32_t i = 0; i < depth; ++i) {
            ostream_->write(space.c_str(), space.length());
        }
        std::string data = "";
        if (childSize == 0) {
            data = "      ";
        } else {
            data = "    | ";
        }
        data.append(desc);
        ostream_->write(data.c_str(), data.length());
    }
    ostream_->flush();
    description_.clear();
    description_.shrink_to_fit();
}

void DumpLog::Print(const std::string& content)
{
    Print(0, content);
}

void DumpLog::Print(int32_t depth, const std::string& content)
{
    std::string space = " ";
    for (int32_t i = 0; i < depth; ++i) {
        ostream_->write(space.c_str(), space.length());
    }
    std::string data = content + "\n";
    ostream_->write(data.c_str(), data.length());
}

void DumpLog::Reset()
{
    ostream_.reset();
}

void DumpLog::ShowDumpHelp(std::vector<std::string>& info)
{
    info.emplace_back(" -element                       |show element tree");
    info.emplace_back(" -render                        |show render tree");
    info.emplace_back(" -inspector                     |show inspector tree");
    info.emplace_back(" -frontend                      |show path and components count of current page");
    info.emplace_back(" -navigation                    |show navigation path stack");
}

void DumpLog::Append(int32_t depth, const std::string& className, int32_t childSize)
{
    for (int32_t i = 0; i < depth; ++i) {
        result_.append("  ");
    }
    result_.append("|-> ");
    result_.append(className);
    result_.append(" childSize:" + std::to_string(childSize));
    result_.append("\n");
    for (auto& desc : description_) {
        for (int32_t i = 0; i < depth; ++i) {
            result_.append("  ");
        }
        if (childSize == 0) {
            result_.append("      ");
        } else {
            result_.append("    | ");
        }
        result_.append(desc);
    }
    description_.clear();
    description_.shrink_to_fit();
}

bool DumpLog::OutPutBySize()
{
    if (!ostream_->good()) {
        result_.clear();
        return false;
    }
    // if current result size > max size, dump will output as file
    if (result_.size() + 1 > DumpLog::MAX_DUMP_LENGTH) {
        auto dumpFilePath = AceApplicationInfo::GetInstance().GetDataFileDirPath() + "/arkui.dump";
        std::unique_ptr<std::ostream> ostream = std::make_unique<std::ofstream>(dumpFilePath);
        if (!ostream) {
            result_.clear();
            result_.append("Dump output failed,please try again");
            ostream_->write(result_.c_str(), result_.length());
            result_.clear();
        }
        CHECK_NULL_RETURN(ostream, false);
        DumpLog::GetInstance().SetDumpFile(std::move(ostream));
    }
    ostream_->write(result_.c_str(), result_.length());
    result_.clear();
    ostream_->flush();
    return true;
}

void DumpLog::OutPutDefault()
{
    if (!ostream_->good()) {
        result_.clear();
        return;
    }
    ostream_->write(result_.c_str(), result_.length());
    result_.clear();
    ostream_->flush();
}
} // namespace OHOS::Ace
